#include <iostream>
using namespace std;

// struct test
// {
//     test(int x) {}
//     // 转换操作符，本来应该是operator()，但是仿函数页是重载()
//     // C++引入了新的概念，想转换成什么就必须要有对应参数的构造函数
//     explicit operator int()
//     {
//         return 1;
//     }
//     int a;
// };
// // int main()
// // {
// //     int a = static_cast<int>(test(1));
// //     int x = 1;
// //     double d = x;
// //     std::cout << a << std::endl;
// //     return 0;
// // }

// int main()
// {
//     volatile const int y = 0;
//     int *x = (int *)&y;
//     *x = 1;
//     std::cout << *x << std::endl;
//     std::cout << y << std::endl;
// }

struct Base
{
    virtual void fucn() {};
    int a = 1;
};
struct Derive : public Base
{
    int c = 1;
};
void func(Base *b)
{
    Derive *p = dynamic_cast<Derive *>(b);
    if (p)
    {
        std::cout << p->a << std::endl;
        std::cout << p->c << std::endl;
    }
    else
        std::cout << "convert fail" << std::endl;
}

void func1(const int *x)
{
    int *c = const_cast<int *>(x);
    // *c = 110;
}
int main()
{
    int a = 10;
    double d = static_cast<int>(a);
    std::cout << d << std::endl;

    Base b;
    Derive de;

    const int *x = &a;
    // int *p = (int *)&x;

    // *p = 1;
    // func1(p);

    // std::cout << *p << std::endl;
    // std::cout << *x << std::endl;

    // func(&b);
    // func(&de);
    // std::cout << b.a << std::endl;
    // // std::cout << b.c << std::endl;

    // std::cout << de.a << std::endl;
    // std::cout << "hello" << std::endl;
    // std::cout << de.c << std::endl;
    std::cout << typeid(int[]).name() << std::endl;
}